home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Tools / glimpse-2.1 / agrep / asearch.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-16  |  28.6 KB  |  967 lines
  1. /* Copyright (c) 1994 Sun Wu, Udi Manber, Burra Gopal.  All Rights Reserved. */
  2. #include "agrep.h"
  3.  
  4. extern unsigned Init1, Init[], Mask[], endposition, D_endpos, AND, NO_ERR_MASK;
  5. extern int DELIMITER, FILENAMEONLY, INVERSE;
  6. extern CHAR CurrentFileName[];
  7. extern int I, num_of_matched, TRUNCATE;
  8.  
  9. extern int CurrentByteOffset;
  10. extern int errno;
  11. extern CHAR *agrep_inbuffer;
  12. extern int  agrep_inlen;
  13. extern int  agrep_initialfd;
  14. extern int  EXITONERROR;
  15. extern int  agrep_inpointer;
  16.  
  17. extern FILE *agrep_finalfp;
  18. extern CHAR *agrep_outbuffer;
  19. extern int agrep_outlen;
  20. extern int agrep_outpointer;
  21.  
  22. extern int NEW_FILE, POST_FILTER;
  23.  
  24. extern int LIMITOUTPUT;
  25.  
  26. asearch(old_D_pat, text, D)
  27. CHAR old_D_pat[]; 
  28. int text; 
  29. register unsigned D;
  30. {
  31.     register unsigned i, c, r1, r2, CMask, r_NO_ERR, r_Init1; 
  32.     register unsigned A0, B0, A1, B1, endpos;
  33.     unsigned A2, B2, A3, B3, A4, B4;
  34.     unsigned A[MaxError+1], B[MaxError+1];
  35.     unsigned D_Mask;
  36.     int end;
  37.     int D_length, FIRSTROUND, ResidueSize, lasti, l, k, j=0;
  38.     int printout_end;
  39.     CHAR *buffer;
  40.     /* CHAR *tempbuf = NULL; */    /* used only when text == -1 */
  41.  
  42.     if (I == 0) Init1 = (unsigned)037777777777;
  43.     if(D > 4) {
  44.         return asearch0(old_D_pat, text, D); 
  45.     }
  46.  
  47.     D_length = strlen(old_D_pat);
  48.     D_Mask = D_endpos;
  49.     for ( i=1; i<D_length; i++) D_Mask = (D_Mask<<1) | D_Mask;
  50.     D_Mask = ~D_Mask;
  51.  
  52.     r_Init1 = Init1; /* put Init1 in register */
  53.     r_NO_ERR = NO_ERR_MASK; /* put NO_ERR_MASK in register */
  54.     endpos = D_endpos;    
  55.     FIRSTROUND = ON;
  56.     A0 = B0 = A1 = B1 = A2 = B2 = A3 = B3 = A4 = B4 = Init[0];
  57.     for(k=0; k<=D; k++) A[k] = B[k] = Init[0];
  58.  
  59. #if    AGREP_POINTER
  60.     if (text != -1) {
  61. #endif    /*AGREP_POINTER*/
  62.         lasti = Max_record;
  63.         alloc_buf(text, &buffer, Max_record+BlockSize+1);
  64.         buffer[Max_record-1] = '\n';
  65.  
  66.         while ((l = fill_buf(text, buffer + Max_record, BlockSize)) > 0)
  67.         {
  68.             i = Max_record;
  69.             end = Max_record + l ;
  70.             if (FIRSTROUND) { 
  71.                 i = Max_record - 1;
  72.                 if(DELIMITER) {
  73.                     for(k=0; k<D_length; k++) {
  74.                         if(old_D_pat[k] != buffer[Max_record+k]) break;
  75.                     }
  76.                     if(k>=D_length) j--;
  77.                 }
  78.                 FIRSTROUND = OFF; 
  79.             }
  80.             if (l < BlockSize) {    /* copy pattern and '\0' at end of buffer */
  81.                 strncpy(buffer+end, old_D_pat, D_length);
  82.                 buffer[end+D_length] = '\0';
  83.                 end = end + D_length; 
  84.             }
  85.  
  86.             /* ASEARCH_PROCESS: the while-loop below */
  87.             while (i < end )
  88.             {
  89.                 c = buffer[i];
  90.                 CMask = Mask[c];
  91.                 r1 = r_Init1 & B0;
  92.                 A0 = ((B0 >>1 ) & CMask) | r1;
  93.                 r1 = r_Init1 & B1;
  94.                 r2 =  B0 | (((A0 | B0) >> 1) & r_NO_ERR); 
  95.                 A1 = ((B1 >>1 ) & CMask) | r2 | r1 ;  
  96.                 if(D == 1) goto Nextcharfile;
  97.                 r1 = r_Init1 & B2;
  98.                 r2 =  B1 | (((A1 | B1) >> 1) & r_NO_ERR); 
  99.                 A2 = ((B2 >>1 ) & CMask) | r2 | r1 ;  
  100.                 if(D == 2) goto Nextcharfile;
  101.                 r1 = r_Init1 & B3;
  102.                 r2 =  B2 | (((A2 | B2) >> 1) & r_NO_ERR); 
  103.                 A3 = ((B3 >>1 ) & CMask) | r2 | r1 ;  
  104.                 if(D == 3) goto Nextcharfile;
  105.                 r1 = r_Init1 & B4;
  106.                 r2 =  B3 | (((A3 | B3) >> 1) & r_NO_ERR); 
  107.                 A4 = ((B4 >>1 ) & CMask) | r2 | r1 ;  
  108.                 if(D == 4) goto Nextcharfile;
  109. Nextcharfile:
  110.                 i=i+1;
  111.                 CurrentByteOffset ++;
  112.                 if(A0 & endpos) {
  113.                     j++;  
  114.                     if (DELIMITER) CurrentByteOffset -= D_length;
  115.                     else CurrentByteOffset -= 1;
  116.                     r1 = A0;
  117.                     if ( D == 1) r1 = A1;
  118.                     if ( D == 2) r1 = A2;
  119.                     if ( D == 3) r1 = A3;
  120.                     if ( D == 4) r1 = A4;
  121.                     if(((AND == 1) && ((r1 & endposition) == endposition)) || ((AND == 0) && (r1 & endposition)) ^ INVERSE )
  122.                     {    
  123.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  124.                             num_of_matched++;
  125.                             if (agrep_finalfp != NULL) 
  126.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  127.                             else {
  128.                                 int outindex;
  129.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  130.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  131.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  132.                                 }
  133.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  134.                                     OUTPUT_OVERFLOW;
  135.                                     /*
  136.                                     if (text == -1) {
  137.                                         memcpy(buffer+end-D_length, tempbuf, D_length+1);
  138.                                     }
  139.                                     */
  140.                                     free_buf(text, buffer);
  141.                                     return -1;
  142.                                 }
  143.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  144.                                 agrep_outpointer += outindex;
  145.                             }
  146.                             /*
  147.                             if (text == -1) {
  148.                                 memcpy(buffer+end-D_length, tempbuf, D_length+1);
  149.                             }
  150.                             */
  151.                             free_buf(text, buffer);
  152.                             NEW_FILE = OFF;
  153.                             return 0;  
  154.                         }
  155.                         printout_end = i - D_length - 1 ; 
  156.                         if ((text != -1) && !(lasti >= Max_record + l - 1)) {
  157.                             if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
  158.                         }
  159.                         else if ((text == -1) && !(lasti >= l)) {
  160.                             if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
  161.                         }
  162.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  163.                             free_buf(text, buffer);
  164.                             return 0;    /* done */
  165.                         }
  166.                     }
  167.                     lasti = i - D_length; /* point to starting position of D_pat */
  168.                     TRUNCATE = OFF;
  169.                     for(k=0; k<= D; k++) {
  170.                         B[k] = Init[0];
  171.                     }
  172.                     r1 = B[0] & Init1;
  173.                     A[0] = (((B[0]>>1) & CMask) | r1) & D_Mask;
  174.                     for(k=1; k<= D; k++) {
  175.                         r1 = Init1 & B[k];
  176.                         r2 = B[k-1] | (((A[k-1] | B[k-1])>>1)&r_NO_ERR);
  177.                         A[k] = (((B[k]>>1)&CMask) | r1 | r2) ;
  178.                     }
  179.                     A0 = A[0]; 
  180.                     B0 = B[0]; 
  181.                     A1 = A[1]; 
  182.                     B1 = B[1]; 
  183.                     A2 = A[2]; 
  184.                     B2 = B[2];
  185.                     A3 = A[3]; 
  186.                     B3 = B[3]; 
  187.                     A4 = A[4]; 
  188.                     B4 = B[4];
  189.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  190.                     else CurrentByteOffset += 1*1;
  191.                 }
  192.                 c = buffer[i];
  193.                 CMask = Mask[c];
  194.                 r1 = r_Init1 & A0;
  195.                 B0 = ((A0 >> 1 ) & CMask) | r1;
  196.                 /* printf("Mask = %o, B0 = %on", CMask, B0); */
  197.                 r1 = r_Init1 & A1;
  198.                 r2 =  A0 | (((A0 | B0) >> 1) & r_NO_ERR); 
  199.                 B1 = ((A1 >>1 ) & CMask) | r2 | r1 ;  
  200.                 if(D == 1) goto Nextchar1file;
  201.                 r1 = r_Init1 & A2;
  202.                 r2 =  A1 | (((A1 | B1) >> 1) & r_NO_ERR); 
  203.                 B2 = ((A2 >>1 ) & CMask) | r2 | r1 ;  
  204.                 if(D == 2) goto Nextchar1file;
  205.                 r1 = r_Init1 & A3;
  206.                 r2 =  A2 | (((A2 | B2) >> 1) & r_NO_ERR); 
  207.                 B3 = ((A3 >>1 ) & CMask) | r2 | r1 ;  
  208.                 if(D == 3) goto Nextchar1file;
  209.                 r1 = r_Init1 & A4;
  210.                 r2 =  A3 | (((A3 | B3) >> 1) & r_NO_ERR); 
  211.                 B4 = ((A4 >>1 ) & CMask) | r2 | r1 ;  
  212.                 if(D == 4) goto Nextchar1file;
  213. Nextchar1file:
  214.                 i=i+1;
  215.                 CurrentByteOffset ++;
  216.                 if(B0 & endpos) {
  217.                     j++;  
  218.                     if (DELIMITER) CurrentByteOffset -= D_length;
  219.                     else CurrentByteOffset -= 1;
  220.                     r1 = B0;
  221.                     if ( D == 1) r1 = B1;
  222.                     if ( D == 2) r1 = B2;
  223.                     if ( D == 3) r1 = B3;
  224.                     if ( D == 4) r1 = B4;
  225.                     if(((AND == 1) && ((r1 & endposition) == endposition)) || ((AND == 0) && (r1 & endposition)) ^ INVERSE )
  226.                     { 
  227.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  228.                             num_of_matched++;
  229.                             free_buf(text, buffer);
  230.                             if (agrep_finalfp != NULL) 
  231.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  232.                             else {
  233.                                 int outindex;
  234.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  235.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  236.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  237.                                 }
  238.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  239.                                     OUTPUT_OVERFLOW;
  240.                                     /*
  241.                                     if (text == -1) {
  242.                                         memcpy(buffer+end-D_length, tempbuf, D_length+1);
  243.                                     }
  244.                                     */
  245.                                     free_buf(text, buffer);
  246.                                     return -1;
  247.                                 }
  248.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  249.                                 agrep_outpointer += outindex;
  250.                             }
  251.                             /*
  252.                             if (text == -1) {
  253.                                 memcpy(buffer+end-D_length, tempbuf, D_length+1);
  254.                             }
  255.                             */
  256.                             free_buf(text, buffer);
  257.                             NEW_FILE = OFF;
  258.                             return 0; 
  259.                         }
  260.                         printout_end = i - D_length - 1 ; 
  261.                         if((text != -1) && !(lasti >= Max_record + l - 1)) {
  262.                             if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
  263.                         }
  264.                         else if ((text == -1) && !(lasti >= l)) {
  265.                             if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
  266.                         }
  267.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  268.                             free_buf(text, buffer);
  269.                             return 0;    /* done */
  270.                         }
  271.                     }
  272.                     lasti = i - D_length ;
  273.                     TRUNCATE = OFF;
  274.                     for(k=0; k<= D; k++) {
  275.                         A[k] = Init[0];
  276.                     }
  277.                     r1 = A[0] & Init1; 
  278.                     B[0] = (((A[0]>>1)&CMask) | r1) & D_Mask;
  279.                     for(k=1; k<= D; k++) {
  280.                         r1 = Init1 & A[k];
  281.                         r2 = A[k-1] | (((A[k-1] | B[k-1])>>1)&r_NO_ERR);
  282.                         B[k] = (((A[k]>>1)&CMask) | r1 | r2) ;
  283.                     }
  284.                     A0 = A[0]; 
  285.                     B0 = B[0]; 
  286.                     A1 = A[1]; 
  287.                     B1 = B[1]; 
  288.                     A2 = A[2]; 
  289.                     B2 = B[2];
  290.                     A3 = A[3]; 
  291.                     B3 = B[3]; 
  292.                     A4 = A[4]; 
  293.                     B4 = B[4];
  294.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  295.                     else CurrentByteOffset += 1*1;
  296.                 }
  297.             }
  298.  
  299.             if(l < BlockSize) {
  300.                 lasti = Max_record ;
  301.             }
  302.             else {
  303.                 ResidueSize = Max_record + l - lasti;
  304.                 if(ResidueSize > Max_record) {
  305.                     ResidueSize = Max_record;
  306.                     TRUNCATE = ON;         
  307.                 }
  308.                 strncpy(buffer+Max_record-ResidueSize, buffer+lasti, ResidueSize);
  309.                 lasti = Max_record - ResidueSize;
  310.                 if(lasti == 0)     lasti = 1; 
  311.             }
  312.         }
  313.         free_buf(text, buffer);
  314.         return 0;
  315. #if    AGREP_POINTER
  316.     }
  317.     else {
  318.         lasti = 1;
  319.         /* if (DELIMITER) tempbuf = (CHAR*)malloc(D_length + 1); */
  320.         buffer = (CHAR *)agrep_inbuffer;
  321.         l = agrep_inlen;
  322.         end = l;
  323.         /* buffer[end-1] = '\n'; */ /* at end of the text. */
  324.         /* buffer[0] = '\n'; */  /* in front of the  text. */
  325.         i = 0;
  326.         if(DELIMITER) {
  327.             for(k=0; k<D_length; k++) {
  328.                 if(old_D_pat[k] != buffer[k]) break;
  329.             }
  330.             if(k>=D_length) j--;
  331.             /*
  332.             memcpy(tempbuf, buffer+end, D_length+1);
  333.             strncpy(buffer+end, old_D_pat, D_length);
  334.             buffer[end+D_length] = '\0';
  335.             end = end + D_length;
  336.             */
  337.         }
  338.  
  339.             /* An exact copy of the above ASEARCH_PROCESS: the while-loop below */
  340.             while (i < end )
  341.             {
  342.                 c = buffer[i];
  343.                 CMask = Mask[c];
  344.                 r1 = r_Init1 & B0;
  345.                 A0 = ((B0 >>1 ) & CMask) | r1;
  346.                 r1 = r_Init1 & B1;
  347.                 r2 =  B0 | (((A0 | B0) >> 1) & r_NO_ERR); 
  348.                 A1 = ((B1 >>1 ) & CMask) | r2 | r1 ;  
  349.                 if(D == 1) goto Nextcharmem;
  350.                 r1 = r_Init1 & B2;
  351.                 r2 =  B1 | (((A1 | B1) >> 1) & r_NO_ERR); 
  352.                 A2 = ((B2 >>1 ) & CMask) | r2 | r1 ;  
  353.                 if(D == 2) goto Nextcharmem;
  354.                 r1 = r_Init1 & B3;
  355.                 r2 =  B2 | (((A2 | B2) >> 1) & r_NO_ERR); 
  356.                 A3 = ((B3 >>1 ) & CMask) | r2 | r1 ;  
  357.                 if(D == 3) goto Nextcharmem;
  358.                 r1 = r_Init1 & B4;
  359.                 r2 =  B3 | (((A3 | B3) >> 1) & r_NO_ERR); 
  360.                 A4 = ((B4 >>1 ) & CMask) | r2 | r1 ;  
  361.                 if(D == 4) goto Nextcharmem;
  362. Nextcharmem: 
  363.                 i=i+1;
  364.                 CurrentByteOffset ++;
  365.                 if(A0 & endpos) {
  366.                     j++;  
  367.                     if (DELIMITER) CurrentByteOffset -= D_length;
  368.                     else CurrentByteOffset -= 1;
  369.                     r1 = A0;
  370.                     if ( D == 1) r1 = A1;
  371.                     if ( D == 2) r1 = A2;
  372.                     if ( D == 3) r1 = A3;
  373.                     if ( D == 4) r1 = A4;
  374.                     if(((AND == 1) && ((r1 & endposition) == endposition)) || ((AND == 0) && (r1 & endposition)) ^ INVERSE )
  375.                     {    
  376.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  377.                             num_of_matched++;
  378.                             if (agrep_finalfp != NULL) 
  379.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  380.                             else {
  381.                                 int outindex;
  382.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  383.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  384.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  385.                                 }
  386.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  387.                                     OUTPUT_OVERFLOW;
  388.                                     /*
  389.                                     if (text == -1) {
  390.                                         memcpy(buffer+end-D_length, tempbuf, D_length+1);
  391.                                     }
  392.                                     */
  393.                                     free_buf(text, buffer);
  394.                                     return -1;
  395.                                 }
  396.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  397.                                 agrep_outpointer += outindex;
  398.                             }
  399.                             /*
  400.                             if (text == -1) {
  401.                                 memcpy(buffer+end-D_length, tempbuf, D_length+1);
  402.                             }
  403.                             */
  404.                             free_buf(text, buffer);
  405.                             NEW_FILE = OFF;
  406.                             return 0;  
  407.                         }
  408.                         printout_end = i - D_length - 1 ; 
  409.                         if ((text != -1) && !(lasti >= Max_record + l - 1)) {
  410.                             if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
  411.                         }
  412.                         else if ((text == -1) && !(lasti >= l)) {
  413.                             if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
  414.                         }
  415.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  416.                             free_buf(text, buffer);
  417.                             return 0;    /* done */
  418.                         }
  419.                     }
  420.                     lasti = i - D_length; /* point to starting position of D_pat */
  421.                     TRUNCATE = OFF;
  422.                     for(k=0; k<= D; k++) {
  423.                         B[k] = Init[0];
  424.                     }
  425.                     r1 = B[0] & Init1;
  426.                     A[0] = (((B[0]>>1) & CMask) | r1) & D_Mask;
  427.                     for(k=1; k<= D; k++) {
  428.                         r1 = Init1 & B[k];
  429.                         r2 = B[k-1] | (((A[k-1] | B[k-1])>>1)&r_NO_ERR);
  430.                         A[k] = (((B[k]>>1)&CMask) | r1 | r2) ;
  431.                     }
  432.                     A0 = A[0]; 
  433.                     B0 = B[0]; 
  434.                     A1 = A[1]; 
  435.                     B1 = B[1]; 
  436.                     A2 = A[2]; 
  437.                     B2 = B[2];
  438.                     A3 = A[3]; 
  439.                     B3 = B[3]; 
  440.                     A4 = A[4]; 
  441.                     B4 = B[4];
  442.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  443.                     else CurrentByteOffset += 1*1;
  444.                 }
  445.                 c = buffer[i];
  446.                 CMask = Mask[c];
  447.                 r1 = r_Init1 & A0;
  448.                 B0 = ((A0 >> 1 ) & CMask) | r1;
  449.                 /* printf("Mask = %o, B0 = %on", CMask, B0); */
  450.                 r1 = r_Init1 & A1;
  451.                 r2 =  A0 | (((A0 | B0) >> 1) & r_NO_ERR); 
  452.                 B1 = ((A1 >>1 ) & CMask) | r2 | r1 ;  
  453.                 if(D == 1) goto Nextchar1mem;
  454.                 r1 = r_Init1 & A2;
  455.                 r2 =  A1 | (((A1 | B1) >> 1) & r_NO_ERR); 
  456.                 B2 = ((A2 >>1 ) & CMask) | r2 | r1 ;  
  457.                 if(D == 2) goto Nextchar1mem;
  458.                 r1 = r_Init1 & A3;
  459.                 r2 =  A2 | (((A2 | B2) >> 1) & r_NO_ERR); 
  460.                 B3 = ((A3 >>1 ) & CMask) | r2 | r1 ;  
  461.                 if(D == 3) goto Nextchar1mem;
  462.                 r1 = r_Init1 & A4;
  463.                 r2 =  A3 | (((A3 | B3) >> 1) & r_NO_ERR); 
  464.                 B4 = ((A4 >>1 ) & CMask) | r2 | r1 ;  
  465.                 if(D == 4) goto Nextchar1mem;
  466. Nextchar1mem: 
  467.                 i=i+1;
  468.                 CurrentByteOffset ++;
  469.                 if(B0 & endpos) {
  470.                     j++;  
  471.                     if (DELIMITER) CurrentByteOffset -= D_length;
  472.                     else CurrentByteOffset -= 1;
  473.                     r1 = B0;
  474.                     if ( D == 1) r1 = B1;
  475.                     if ( D == 2) r1 = B2;
  476.                     if ( D == 3) r1 = B3;
  477.                     if ( D == 4) r1 = B4;
  478.                     if(((AND == 1) && ((r1 & endposition) == endposition)) || ((AND == 0) && (r1 & endposition)) ^ INVERSE )
  479.                     { 
  480.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  481.                             num_of_matched++;
  482.                             free_buf(text, buffer);
  483.                             if (agrep_finalfp != NULL) 
  484.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  485.                             else {
  486.                                 int outindex;
  487.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  488.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  489.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  490.                                 }
  491.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  492.                                     OUTPUT_OVERFLOW;
  493.                                     /*
  494.                                     if (text == -1) {
  495.                                         memcpy(buffer+end-D_length, tempbuf, D_length+1);
  496.                                     }
  497.                                     */
  498.                                     free_buf(text, buffer);
  499.                                     return -1;
  500.                                 }
  501.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  502.                                 agrep_outpointer += outindex;
  503.                             }
  504.                             /*
  505.                             if (text == -1) {
  506.                                 memcpy(buffer+end-D_length, tempbuf, D_length+1);
  507.                             }
  508.                             */
  509.                             free_buf(text, buffer);
  510.                             NEW_FILE = OFF;
  511.                             return 0; 
  512.                         }
  513.                         printout_end = i - D_length - 1 ; 
  514.                         if((text != -1) && !(lasti >= Max_record + l - 1)) {
  515.                             if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
  516.                         }
  517.                         else if ((text == -1) && !(lasti >= l)) {
  518.                             if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
  519.                         }
  520.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  521.                             free_buf(text, buffer);
  522.                             return 0;    /* done */
  523.                         }
  524.                     }
  525.                     lasti = i - D_length ;
  526.                     TRUNCATE = OFF;
  527.                     for(k=0; k<= D; k++) {
  528.                         A[k] = Init[0];
  529.                     }
  530.                     r1 = A[0] & Init1; 
  531.                     B[0] = (((A[0]>>1)&CMask) | r1) & D_Mask;
  532.                     for(k=1; k<= D; k++) {
  533.                         r1 = Init1 & A[k];
  534.                         r2 = A[k-1] | (((A[k-1] | B[k-1])>>1)&r_NO_ERR);
  535.                         B[k] = (((A[k]>>1)&CMask) | r1 | r2) ;
  536.                     }
  537.                     A0 = A[0]; 
  538.                     B0 = B[0]; 
  539.                     A1 = A[1]; 
  540.                     B1 = B[1]; 
  541.                     A2 = A[2]; 
  542.                     B2 = B[2];
  543.                     A3 = A[3]; 
  544.                     B3 = B[3]; 
  545.                     A4 = A[4]; 
  546.                     B4 = B[4];
  547.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  548.                     else CurrentByteOffset += 1*1;
  549.                 }
  550.             }
  551.  
  552.         /*
  553.         if (DELIMITER) {
  554.             memcpy(buffer+end, tempbuf, D_length+1);
  555.             free(tempbuf);
  556.         }
  557.         */
  558.         return 0;
  559.     }
  560. #endif    /*AGREP_POINTER*/
  561. }
  562.  
  563. asearch0(old_D_pat, text, D)
  564. CHAR old_D_pat[]; 
  565. int text; 
  566. register unsigned D;
  567. {
  568.     register unsigned i, c, r1, r2, CMask, r_NO_ERR, r_Init1,  end, endpos; 
  569.     unsigned A[MaxError+2], B[MaxError+2];
  570.     unsigned D_Mask;
  571.     int D_length, FIRSTROUND, ResidueSize, lasti, l, k, j=0;
  572.     int printout_end;
  573.     CHAR *buffer;
  574.     /* CHAR *tempbuf = NULL;*/    /* used only when text == -1 */
  575.  
  576.     D_length = strlen(old_D_pat);
  577.     D_Mask = D_endpos;
  578.     for ( i=1; i<D_length; i++) D_Mask = (D_Mask<<1) | D_Mask;
  579.     D_Mask = ~D_Mask;
  580.  
  581.     r_Init1 = Init1; /* put Init1 in register */
  582.     r_NO_ERR = NO_ERR_MASK; /* put NO_ERR_MASK in register */
  583.     endpos = D_endpos;    
  584.     FIRSTROUND = ON;
  585.     for(k=0; k<=D; k++) A[k] = B[k] = Init[0];
  586.  
  587. #if    AGREP_POINTER
  588.     if (text != -1) {
  589. #endif    /*AGREP_POINTER*/
  590.         lasti = Max_record;
  591.         alloc_buf(text, &buffer, BlockSize+Max_record+1);
  592.         buffer[Max_record-1] = '\n';
  593.         while ((l = fill_buf(text, buffer + Max_record, BlockSize)) > 0)
  594.         {
  595.             i = Max_record; 
  596.             end = Max_record + l ;
  597.             if (FIRSTROUND) { 
  598.                 i = Max_record - 1;
  599.                 FIRSTROUND = OFF; 
  600.             }
  601.             if (l < BlockSize) {
  602.                 strncpy(buffer+end, old_D_pat, D_length);
  603.                 buffer[end+D_length] = '\0';
  604.                 end = end + D_length; 
  605.             }
  606.  
  607.             /* ASEARCH0_PROCESS: the while-loop below */
  608.             while (i < end )
  609.             {
  610.                 c = buffer[i++];
  611.                 CurrentByteOffset ++;
  612.                 CMask = Mask[c];
  613.                 r1 = B[0] & r_Init1;
  614.                 A[0] = (((B[0] >> 1)) & CMask | r1 ) ;
  615.                 for(k=1; k<=D; k++) {
  616.                     r1 = r_Init1 & B[k];
  617.                     r2 = B[k-1] | (((A[k-1]|B[k-1])>>1) & r_NO_ERR);
  618.                     A[k] = ((B[k] >> 1) & CMask) | r2 | r1;
  619.                 }
  620.                 if(A[0] & endpos) {
  621.                     j++;  
  622.                     if (DELIMITER) CurrentByteOffset -= D_length;
  623.                     else CurrentByteOffset -= 1;
  624.                     r1 = A[D];
  625.                     if(((AND == 1) && ((r1 & endposition) == endposition)) || ((AND == 0) && (r1 & endposition)) ^ INVERSE )
  626.                     {    
  627.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  628.                             num_of_matched++;
  629.                             if (agrep_finalfp != NULL) 
  630.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  631.                             else {
  632.                                 int outindex;
  633.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  634.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  635.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  636.                                 }
  637.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  638.                                     OUTPUT_OVERFLOW;
  639.                                     /*
  640.                                     if (text == -1) {
  641.                                         memcpy(buffer+end-D_length, tempbuf, D_length+1);
  642.                                     }
  643.                                     */
  644.                                     free_buf(text, buffer);
  645.                                     return -1;
  646.                                 }
  647.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  648.                                 agrep_outpointer += outindex;
  649.                             }
  650.                             /*
  651.                             if (text == -1) {
  652.                                 memcpy(buffer+end-D_length, tempbuf, D_length+1);
  653.                             }
  654.                             */
  655.                             free_buf(text, buffer);
  656.                             NEW_FILE = OFF;
  657.                             return 0;  
  658.                         }
  659.                         printout_end = i - D_length - 1;           
  660.                         if((text != -1) && !(lasti >= Max_record + l - 1)) {
  661.                             if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
  662.                         }
  663.                         else if ((text == -1) && !(lasti >= l)) {
  664.                             if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
  665.                         }
  666.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  667.                             free_buf(text, buffer);
  668.                             return 0;    /* done */
  669.                         }
  670.                     }
  671.                     lasti = i - D_length; /* point to starting position of D_pat */
  672.                     for(k=0; k<= D; k++) {
  673.                         B[k] = Init[0];
  674.                     }
  675.                     r1 = B[0] & r_Init1;
  676.                     A[0] = (((B[0]>>1) & CMask) | r1) & D_Mask;
  677.                     for(k=1; k<= D; k++) {
  678.                         r1 = Init1 & B[k];
  679.                         r2 = B[k-1] | (((A[k-1] | B[k-1])>>1)&r_NO_ERR);
  680.                         A[k] = (((B[k]>>1)&CMask) | r1 | r2) ;
  681.                     }
  682.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  683.                     else CurrentByteOffset += 1*1;
  684.                 }
  685.                 c = buffer[i++];
  686.                 CurrentByteOffset ++;
  687.                 CMask = Mask[c];
  688.                 r1   = r_Init1 & A[0];
  689.                 B[0] = ((A[0] >> 1 ) & CMask) | r1;
  690.                 for(k=1; k<=D; k++) {
  691.                     r1 = r_Init1 & A[k];
  692.                     r2 = A[k-1] | (((A[k-1]|B[k-1])>>1) & r_NO_ERR);
  693.                     B[k] = ((A[k] >> 1) & CMask) | r2 | r1;
  694.                 }
  695.                 if(B[0] & endpos) {
  696.                     j++;  
  697.                     if (DELIMITER) CurrentByteOffset -= D_length;
  698.                     else CurrentByteOffset -= 1;
  699.                     r1 = B[D];
  700.                     if(((AND == 1) && ((r1 & endposition) == endposition)) || ((AND == 0) && (r1 & endposition)) ^ INVERSE )
  701.                     { 
  702.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  703.                             num_of_matched++;
  704.                             if (agrep_finalfp != NULL) 
  705.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  706.                             else {
  707.                                 int outindex;
  708.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  709.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  710.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  711.                                 }
  712.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  713.                                     OUTPUT_OVERFLOW;
  714.                                     /*
  715.                                     if (text == -1) {
  716.                                         memcpy(buffer+end-D_length, tempbuf, D_length+1);
  717.                                     }
  718.                                     */
  719.                                     free_buf(text, buffer);
  720.                                     return -1;
  721.                                 }
  722.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  723.                                 agrep_outpointer += outindex;
  724.                             }
  725.                             /*
  726.                             if (text == -1) {
  727.                                 memcpy(buffer+end-D_length, tempbuf, D_length+1);
  728.                             }
  729.                             */
  730.                             free_buf(text, buffer);
  731.                             NEW_FILE = OFF;
  732.                             return 0; 
  733.                         }
  734.                         printout_end = i - D_length -1 ; 
  735.                         if((text != -1) && !(lasti >= Max_record + l - 1)) {
  736.                             if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
  737.                         }
  738.                         else if ((text == -1) && !(lasti >= l)) {
  739.                             if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
  740.                         }
  741.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  742.                             free_buf(text, buffer);
  743.                             return 0;    /* done */
  744.                         }
  745.                     }
  746.                     lasti = i - D_length ;
  747.                     for(k=0; k<= D; k++) {
  748.                         A[k] = Init[0];
  749.                     }
  750.                     r1 = A[0] & r_Init1; 
  751.                     B[0] = (((A[0]>>1)&CMask) | r1) & D_Mask;
  752.                     for(k=1; k<= D; k++) {
  753.                         r1 = r_Init1 & A[k];
  754.                         r2 = A[k-1] | (((A[k-1] | B[k-1])>>1)&r_NO_ERR);
  755.                         B[k] = (((A[k]>>1)&CMask) | r1 | r2) ;
  756.                     }
  757.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  758.                     else CurrentByteOffset += 1*1;
  759.                 }
  760.             }
  761.  
  762.             if(l < BlockSize) {
  763.                 lasti = Max_record;
  764.             }
  765.             else {
  766.                 ResidueSize = Max_record + l - lasti;
  767.                 if(ResidueSize > Max_record) {
  768.                     ResidueSize = Max_record;
  769.                     TRUNCATE = ON;         
  770.                 }
  771.                 strncpy(buffer+Max_record-ResidueSize, buffer+lasti, ResidueSize);
  772.                 lasti = Max_record - ResidueSize;
  773.                 if(lasti == 0)     lasti = 1; 
  774.             }
  775.         }
  776.         free_buf(text, buffer);
  777.         return 0;
  778. #if    AGREP_POINTER
  779.     }
  780.     else {
  781.         lasti = 1;
  782.         /* if (DELIMITER) tempbuf = (CHAR*)malloc(D_length + 1); */
  783.         buffer = (CHAR *)agrep_inbuffer;
  784.         l = agrep_inlen;
  785.         end = l;
  786.         /* buffer[end-1] = '\n';*/ /* at end of the text. */
  787.         /* buffer[0] = '\n';*/  /* in front of the  text. */
  788.         i = 0;
  789.         if(DELIMITER) {
  790.             for(k=0; k<D_length; k++) {
  791.                 if(old_D_pat[k] != buffer[k]) break;
  792.             }
  793.             if(k>=D_length) j--;
  794.             /*
  795.             memcpy(tempbuf, buffer+end, D_length+1);
  796.             strncpy(buffer+end, old_D_pat, D_length);
  797.             buffer[end+D_length] = '\0';
  798.             end = end + D_length;
  799.             */
  800.         }
  801.  
  802.             /* An exact copy of the above ASEARCH0_PROCESS: the while-loop below */
  803.             while (i < end )
  804.             {
  805.                 c = buffer[i++];
  806.                 CurrentByteOffset ++;
  807.                 CMask = Mask[c];
  808.                 r1 = B[0] & r_Init1;
  809.                 A[0] = (((B[0] >> 1)) & CMask | r1 ) ;
  810.                 for(k=1; k<=D; k++) {
  811.                     r1 = r_Init1 & B[k];
  812.                     r2 = B[k-1] | (((A[k-1]|B[k-1])>>1) & r_NO_ERR);
  813.                     A[k] = ((B[k] >> 1) & CMask) | r2 | r1;
  814.                 }
  815.                 if(A[0] & endpos) {
  816.                     if (DELIMITER) CurrentByteOffset -= D_length;
  817.                     else CurrentByteOffset -= 1;
  818.                     j++;  
  819.                     r1 = A[D];
  820.                     if(((AND == 1) && ((r1 & endposition) == endposition)) || ((AND == 0) && (r1 & endposition)) ^ INVERSE )
  821.                     {    
  822.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  823.                             num_of_matched++;
  824.                             if (agrep_finalfp != NULL) 
  825.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  826.                             else {
  827.                                 int outindex;
  828.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  829.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  830.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  831.                                 }
  832.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  833.                                     OUTPUT_OVERFLOW;
  834.                                     /*
  835.                                     if (text == -1) {
  836.                                         memcpy(buffer+end-D_length, tempbuf, D_length+1);
  837.                                     }
  838.                                     */
  839.                                     free_buf(text, buffer);
  840.                                     return -1;
  841.                                 }
  842.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  843.                                 agrep_outpointer += outindex;
  844.                             }
  845.                             /*
  846.                             if (text == -1) {
  847.                                 memcpy(buffer+end-D_length, tempbuf, D_length+1);
  848.                             }
  849.                             */
  850.                             free_buf(text, buffer);
  851.                             NEW_FILE = OFF;
  852.                             return 0;  
  853.                         }
  854.                         printout_end = i - D_length - 1;           
  855.                         if((text != -1) && !(lasti >= Max_record + l - 1)) {
  856.                             if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
  857.                         }
  858.                         else if ((text == -1) && !(lasti >= l)) {
  859.                             if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
  860.                         }
  861.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  862.                             free_buf(text, buffer);
  863.                             return 0;    /* done */
  864.                         }
  865.                     }
  866.                     lasti = i - D_length; /* point to starting position of D_pat */
  867.                     for(k=0; k<= D; k++) {
  868.                         B[k] = Init[0];
  869.                     }
  870.                     r1 = B[0] & r_Init1;
  871.                     A[0] = (((B[0]>>1) & CMask) | r1) & D_Mask;
  872.                     for(k=1; k<= D; k++) {
  873.                         r1 = Init1 & B[k];
  874.                         r2 = B[k-1] | (((A[k-1] | B[k-1])>>1)&r_NO_ERR);
  875.                         A[k] = (((B[k]>>1)&CMask) | r1 | r2) ;
  876.                     }
  877.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  878.                     else CurrentByteOffset += 1*1;
  879.                 }
  880.                 c = buffer[i++];
  881.                 CurrentByteOffset ++;
  882.                 CMask = Mask[c];
  883.                 r1   = r_Init1 & A[0];
  884.                 B[0] = ((A[0] >> 1 ) & CMask) | r1;
  885.                 for(k=1; k<=D; k++) {
  886.                     r1 = r_Init1 & A[k];
  887.                     r2 = A[k-1] | (((A[k-1]|B[k-1])>>1) & r_NO_ERR);
  888.                     B[k] = ((A[k] >> 1) & CMask) | r2 | r1;
  889.                 }
  890.                 if(B[0] & endpos) {
  891.                     j++;  
  892.                     if (DELIMITER) CurrentByteOffset -= D_length;
  893.                     else CurrentByteOffset -= 1;
  894.                     r1 = B[D];
  895.                     if(((AND == 1) && ((r1 & endposition) == endposition)) || ((AND == 0) && (r1 & endposition)) ^ INVERSE )
  896.                     { 
  897.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  898.                             num_of_matched++;
  899.                             if (agrep_finalfp != NULL) 
  900.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  901.                             else {
  902.                                 int outindex;
  903.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  904.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  905.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  906.                                 }
  907.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  908.                                     OUTPUT_OVERFLOW;
  909.                                     /*
  910.                                     if (text == -1) {
  911.                                         memcpy(buffer+end-D_length, tempbuf, D_length+1);
  912.                                     }
  913.                                     */
  914.                                     free_buf(text, buffer);
  915.                                     return -1;
  916.                                 }
  917.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  918.                                 agrep_outpointer += outindex;
  919.                             }
  920.                             /*
  921.                             if (text == -1) {
  922.                                 memcpy(buffer+end-D_length, tempbuf, D_length+1);
  923.                             }
  924.                             */
  925.                             free_buf(text, buffer);
  926.                             NEW_FILE = OFF;
  927.                             return 0; 
  928.                         }
  929.                         printout_end = i - D_length -1 ; 
  930.                         if((text != -1) && !(lasti >= Max_record + l - 1)) {
  931.                             if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
  932.                         }
  933.                         else if ((text == -1) && !(lasti >= l)) {
  934.                             if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
  935.                         }
  936.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  937.                             free_buf(text, buffer);
  938.                             return 0;    /* done */
  939.                         }
  940.                     }
  941.                     lasti = i - D_length ;
  942.                     for(k=0; k<= D; k++) {
  943.                         A[k] = Init[0];
  944.                     }
  945.                     r1 = A[0] & r_Init1; 
  946.                     B[0] = (((A[0]>>1)&CMask) | r1) & D_Mask;
  947.                     for(k=1; k<= D; k++) {
  948.                         r1 = r_Init1 & A[k];
  949.                         r2 = A[k-1] | (((A[k-1] | B[k-1])>>1)&r_NO_ERR);
  950.                         B[k] = (((A[k]>>1)&CMask) | r1 | r2) ;
  951.                     }
  952.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  953.                     else CurrentByteOffset += 1*1;
  954.                 }
  955.             }
  956.  
  957.         /*
  958.         if (DELIMITER) {
  959.             memcpy(buffer+end, tempbuf, D_length+1);
  960.             free(tempbuf);
  961.         }
  962.         */
  963.         return 0;
  964.     }
  965. #endif    /*AGREP_POINTER*/
  966. }
  967.